home *** CD-ROM | disk | FTP | other *** search
/ Chip 1996 September / CHIP Eylül 1996.iso / utils / povray / povsrc.lzh / source / tokenize.c < prev    next >
C/C++ Source or Header  |  1994-02-06  |  25KB  |  1,049 lines
  1. /****************************************************************************
  2. *                tokenize.c
  3. *
  4. *  This module implements the first part of a two part parser for the scene
  5. *  description files.  This phase changes the input file into tokens.
  6. *
  7. *  from Persistence of Vision Raytracer
  8. *  Copyright 1993 Persistence of Vision Team
  9. *---------------------------------------------------------------------------
  10. *  NOTICE: This source code file is provided so that users may experiment
  11. *  with enhancements to POV-Ray and to port the software to platforms other 
  12. *  than those supported by the POV-Ray Team.  There are strict rules under
  13. *  which you are permitted to use this file.  The rules are in the file
  14. *  named POVLEGAL.DOC which should be distributed with this file. If 
  15. *  POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  16. *  Team Coordinator by leaving a message in CompuServe's Graphics Developer's
  17. *  Forum.  The latest version of POV-Ray may be found there as well.
  18. *
  19. * This program is based on the popular DKB raytracer version 2.12.
  20. * DKBTrace was originally written by David K. Buck.
  21. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  22. *
  23. *****************************************************************************/
  24.  
  25. #include <ctype.h>
  26. #include "frame.h"
  27. #include "povproto.h"
  28. #include "parse.h"
  29.  
  30. /* This module tokenizes the input file and sends the tokens created
  31. to the parser (the second stage).  Tokens sent to the parser contain a
  32. token ID, the line number of the token, and if necessary, some data for
  33. the token.  */
  34.  
  35. char String[MAX_STRING_INDEX];
  36. int String_Index;
  37. extern int Stop_Flag;
  38. static int pov_stricmp PARAMS ((char *s1,char *s2));
  39.  
  40. /* Here are the reserved words.  If you need to add new words, be sure
  41. to declare them in frame.h */
  42.  
  43.   struct Reserved_Word_Struct Reserved_Words [LAST_TOKEN] = {
  44.   ADAPTIVE_TOKEN, "adaptive",
  45.   AGATE_TOKEN, "agate",
  46.   AGATE_TURB_TOKEN, "agate_turb",
  47.   ALL_TOKEN, "all",
  48.   ALPHA_TOKEN, "alpha",
  49.   AMBIENT_TOKEN, "ambient",
  50.   AMPERSAND_TOKEN, "&",
  51.   AREA_LIGHT_TOKEN, "area_light",
  52.   AT_TOKEN, "@",
  53.   BACKGROUND_TOKEN, "background",
  54.   BACK_QUOTE_TOKEN, "`",
  55.   BACK_SLASH_TOKEN, "\\",
  56.   BAR_TOKEN, "|",
  57.   BICUBIC_PATCH_TOKEN, "bicubic_patch",
  58.   BLOB_TOKEN, "blob",
  59.   BLUE_TOKEN, "blue",
  60.   BOUNDED_BY_TOKEN, "bounded_by",
  61.   BOX_TOKEN, "box",
  62.   BOZO_TOKEN, "bozo",
  63.   BRICK_TOKEN, "brick",
  64.   BRILLIANCE_TOKEN, "brilliance",
  65.   BUMPS_TOKEN, "bumps",
  66.   BUMPY1_TOKEN, "bumpy1",
  67.   BUMPY2_TOKEN, "bumpy2",
  68.   BUMPY3_TOKEN, "bumpy3",
  69.   BUMP_MAP_TOKEN, "bump_map",
  70.   BUMP_SIZE_TOKEN, "bump_size",
  71.   CAMERA_ID_TOKEN, "camera identifier",
  72.   CAMERA_TOKEN, "camera",
  73.   CHECKER_TOKEN, "checker",
  74.   CLIPPED_BY_TOKEN, "clipped_by",
  75.   CLOCK_TOKEN,"clock",
  76.   COLON_TOKEN, ":",
  77.   COLOUR_ID_TOKEN, "colour identifier", 
  78.   COLOUR_MAP_ID_TOKEN, "colour map identifier",
  79.   COLOUR_MAP_TOKEN, "color_map",
  80.   COLOUR_MAP_TOKEN, "colour_map",
  81.   COLOUR_TOKEN, "color",
  82.   COLOUR_TOKEN, "colour",
  83.   COMMA_TOKEN, ",",
  84.   COMPONENT_TOKEN, "component",
  85.   COMPOSITE_TOKEN, "composite",
  86.   CONE_TOKEN, "cone",
  87.   CRAND_TOKEN, "crand",
  88.   CUBIC_TOKEN, "cubic",
  89.   CYLINDER_TOKEN, "cylinder",
  90.   DASH_TOKEN, "-",
  91.   DECLARE_TOKEN, "declare",
  92.   DEFAULT_TOKEN, "default",
  93.   DENTS_TOKEN, "dents",
  94.   DIFFERENCE_TOKEN, "difference",
  95.   DIFFUSE_TOKEN, "diffuse",
  96.   DIRECTION_TOKEN, "direction",
  97.   DISC_TOKEN, "disc",
  98.   DISTANCE_TOKEN, "distance",
  99.   DOLLAR_TOKEN, "$",
  100.   DUMP_TOKEN, "dump",
  101.   END_OF_FILE_TOKEN, "End of File",
  102.   EQUALS_TOKEN, "=",
  103.   EXCLAMATION_TOKEN, "!",
  104.   FALLOFF_TOKEN, "falloff",
  105.   FILTER_TOKEN, "filter",
  106.   FINISH_ID_TOKEN, "finish identifier",
  107.   FINISH_TOKEN, "finish",
  108.   FLATNESS_TOKEN, "flatness",
  109.   FLOAT_ID_TOKEN, "float identifier",
  110.   FLOAT_TOKEN, "float constant",
  111.   FOG_TOKEN, "fog",
  112.   FREQUENCY_TOKEN, "frequency",
  113.   GIF_TOKEN, "gif",
  114.   GRADIENT_TOKEN, "gradient",
  115.   GRANITE_TOKEN, "granite",
  116.   GREEN_TOKEN, "green",
  117.   HASH_TOKEN, "#",
  118.   HAT_TOKEN, "^",
  119.   HEIGHT_FIELD_TOKEN, "height_field",
  120.   HEXAGON_TOKEN, "hexagon",
  121.   IDENTIFIER_TOKEN, "undeclared identifier",
  122.   IFF_TOKEN, "iff",
  123.   IMAGE_MAP_TOKEN, "image_map",
  124.   INCLUDE_TOKEN, "include",
  125.   INTERPOLATE_TOKEN, "interpolate",
  126.   INTERSECTION_TOKEN, "intersection",
  127.   INVERSE_TOKEN, "inverse",
  128.   IOR_TOKEN, "ior",
  129.   JITTER_TOKEN, "jitter",
  130.   LAMBDA_TOKEN, "lambda",
  131.   LEFT_ANGLE_TOKEN, "<",
  132.   LEFT_CURLY_TOKEN, "{",
  133.   LEFT_PAREN_TOKEN, "(",
  134.   LEFT_SQUARE_TOKEN, "[",
  135.   LEOPARD_TOKEN, "leopard",
  136.   LIGHT_SOURCE_TOKEN, "light_source",
  137.   LOCATION_TOKEN, "location",
  138.   LOOKS_LIKE_TOKEN, "looks_like",
  139.   LOOK_AT_TOKEN, "look_at",
  140.   MANDEL_TOKEN,"mandel",
  141.   MAP_TYPE_TOKEN, "map_type",
  142.   MARBLE_TOKEN, "marble",
  143.   MATERIAL_MAP_TOKEN, "material_map",
  144.   MAX_INTERSECTIONS, "max_intersections",
  145.   MAX_TRACE_LEVEL_TOKEN, "max_trace_level",
  146.   MERGE_TOKEN,"merge",
  147.   METALLIC_TOKEN, "metallic",
  148.   MORTAR_TOKEN, "mortar",
  149.   NO_SHADOW_TOKEN, "no_shadow",
  150.   OBJECT_ID_TOKEN, "object identifier",
  151.   OBJECT_TOKEN, "object",
  152.   OCTAVES_TOKEN, "octaves",
  153.   OMEGA_TOKEN, "omega",
  154.   ONCE_TOKEN, "once",
  155.   ONION_TOKEN, "onion",
  156.   OPEN_TOKEN, "open",
  157.   PAINTED1_TOKEN, "painted1",
  158.   PAINTED2_TOKEN, "painted2",
  159.   PAINTED3_TOKEN, "painted3",
  160.   PERCENT_TOKEN, "%",
  161.   PHASE_TOKEN, "phase",
  162.   PHONG_SIZE_TOKEN, "phong_size",
  163.   PHONG_TOKEN, "phong",
  164.   PIGMENT_ID_TOKEN, "pigment identifier",
  165.   PIGMENT_TOKEN, "pigment",
  166.   PLANE_TOKEN, "plane",
  167.   PLUS_TOKEN, "+",
  168.   POINT_AT_TOKEN, "point_at",
  169.   POLY_TOKEN, "poly",
  170.   POT_TOKEN, "pot",
  171.   QUADRIC_TOKEN, "quadric",
  172.   QUARTIC_TOKEN, "quartic",
  173.   QUESTION_TOKEN, "?",
  174.   QUICK_COLOUR_TOKEN,"quick_color",
  175.   QUICK_COLOUR_TOKEN,"quick_colour",
  176.   RADIAL_TOKEN, "radial",
  177.   RADIUS_TOKEN, "radius",
  178.   RAW_TOKEN, "raw",
  179.   RED_TOKEN, "red",
  180.   REFLECTION_TOKEN, "reflection",
  181.   REFRACTION_TOKEN, "refraction",
  182.   RGBF_TOKEN,"rgbf",
  183.   RGB_TOKEN,"rgb",
  184.   RIGHT_ANGLE_TOKEN, ">",
  185.   RIGHT_CURLY_TOKEN, "}",
  186.   RIGHT_PAREN_TOKEN, ")",
  187.   RIGHT_SQUARE_TOKEN, "]",
  188.   RIGHT_TOKEN, "right",
  189.   RIPPLES_TOKEN, "ripples",
  190.   ROTATE_TOKEN, "rotate",
  191.   ROUGHNESS_TOKEN, "roughness",
  192.   SCALE_TOKEN, "scale",
  193.   SEMI_COLON_TOKEN, ";",
  194.   SINGLE_QUOTE_TOKEN, "'",
  195.   SKY_TOKEN, "sky",
  196.   SLASH_TOKEN, "/",
  197.   SMOOTH_TOKEN,"smooth",
  198.   SMOOTH_TRIANGLE_TOKEN, "smooth_triangle",
  199.   SPECULAR_TOKEN, "specular",
  200.   SPHERE_TOKEN, "sphere",
  201.   SPOTLIGHT_TOKEN, "spotlight",
  202.   SPOTTED_TOKEN, "spotted",
  203.   STAR_TOKEN, "*",
  204.   STRING_TOKEN, "string",
  205.   STURM_TOKEN, "sturm",
  206.   TEXTURE_ID_TOKEN, "texture identifier",
  207.   TEXTURE_TOKEN, "texture",
  208.   TGA_TOKEN, "tga",
  209.   THRESHOLD_TOKEN, "threshold",
  210.   TIGHTNESS_TOKEN, "tightness",
  211.   TILDE_TOKEN, "~",
  212.   TILE2_TOKEN, "tile2",
  213.   TILES_TOKEN, "tiles",
  214.   TNORMAL_ID_TOKEN, "normal identifier",
  215.   TNORMAL_TOKEN, "normal",
  216.   TORUS_TOKEN, "torus",
  217.   TRACK_TOKEN, "track",
  218.   TRANSFORM_ID_TOKEN, "transform identifier",
  219.   TRANSFORM_TOKEN, "transform",
  220.   TRANSLATE_TOKEN, "translate",
  221.   TRIANGLE_TOKEN, "triangle",
  222.   TURBULENCE_TOKEN, "turbulence",
  223.   TYPE_TOKEN, "type",
  224.   UNION_TOKEN, "union",
  225.   UP_TOKEN, "up",
  226.   USE_COLOUR_TOKEN,"use_color",
  227.   USE_COLOUR_TOKEN,"use_colour",
  228.   USE_INDEX_TOKEN,"use_index",
  229.   U_STEPS_TOKEN, "u_steps",
  230.   VECTOR_ID_TOKEN, "vector identifier",
  231.   VERSION_TOKEN, "version",
  232.   V_STEPS_TOKEN, "v_steps",
  233.   WATER_LEVEL_TOKEN, "water_level",
  234.   WAVES_TOKEN, "waves",
  235.   WOOD_TOKEN, "wood",
  236.   WRINKLES_TOKEN, "wrinkles",
  237.   X_TOKEN,"x",
  238.   Y_TOKEN,"y",
  239.   Z_TOKEN,"z"
  240.   };
  241.  
  242. /* Make a table for user-defined symbols.  500 symbols should be more
  243. than enough. */
  244.  
  245. /* Now defined in POVRAY.c */
  246. /* #define MAX_SYMBOLS 500 */
  247. extern int Max_Symbols;
  248.  
  249. int token_count = 0, line_count = 10; /* moved here to allow reinitialization */
  250.  
  251. char **Symbol_Table;
  252. int Number_Of_Symbols;
  253. extern int Case_Sensitive_Flag; /* defined & init in pvray.c */
  254. extern unsigned int Options;
  255.  
  256. #define MAX_INCLUDE_FILES 10
  257.  
  258. DATA_FILE Include_Files[MAX_INCLUDE_FILES];
  259. int Include_File_Index;
  260. DATA_FILE *Data_File;
  261.  
  262. struct Token_Struct Token;
  263.  
  264. #define CALL(x) { if (!(x)) return (FALSE); }
  265.  
  266. void Initialize_Tokenizer(filename)
  267. char *filename;
  268.   {
  269.   Symbol_Table = NULL;
  270.   Data_File = NULL;
  271.  
  272.   Include_File_Index = 0;
  273.   Data_File = &Include_Files[0];
  274.  
  275.   Data_File->File = Locate_File (filename, "r");
  276.   if (Data_File->File == NULL)
  277.     {
  278.     fprintf (stderr, "Cannot open input file\n");
  279.     exit(1);
  280.     }
  281.  
  282.   Data_File->Filename = malloc(strlen(filename) + 1);
  283.   strcpy (Data_File->Filename, filename);
  284.   Data_File->Line_Number = 0;
  285.  
  286.   if ((Symbol_Table = (char **) malloc ((Max_Symbols+1) * sizeof (char *))) == NULL) 
  287.     MAError("symbol table");
  288.  
  289.   Token.Token_Line_No = 0;
  290.   Token.Token_String  = NULL;
  291.   Token.Unget_Token   = FALSE;
  292.   Token.End_Of_File   = FALSE;
  293.   Token.Filename      = NULL;
  294.   Token.Constant_Data = NULL;
  295.  
  296.   Number_Of_Symbols = 0;
  297.   }
  298.  
  299.  
  300. void Terminate_Tokenizer()
  301.   {
  302.   int i;
  303.  
  304.   if (Symbol_Table != NULL)
  305.     {
  306.     for (i = 1 ; i < Number_Of_Symbols ; i++)
  307.       free(Symbol_Table[i]);
  308.     free (Symbol_Table);
  309.     }
  310.  
  311.   if (Data_File != NULL)
  312.     {
  313.     fclose (Data_File->File);
  314.     free (Data_File->Filename);
  315.     }
  316.   }
  317.  
  318. /* The main tokenizing routine.  Set up the files and continue parsing
  319. until the end of file */
  320.  
  321. /* This function performs most of the work involved in tokenizing.  It
  322.    reads the first character of the token and decides which function to
  323.    call to tokenize the rest.  For simple tokens, it simply writes them
  324.    out to the token buffer.  */
  325.  
  326. /* Read a token from the input file and store it in the Token variable.
  327. If the token is an INCLUDE token, then set the include file name and
  328. read another token. */
  329.  
  330. void Get_Token ()
  331.   {
  332.   register int c,c2;
  333.  
  334.   if (Token.Unget_Token)
  335.     {
  336.     Token.Unget_Token = FALSE;
  337.     return;
  338.     }
  339.  
  340.   if (Token.End_Of_File)
  341.     return;
  342.  
  343.  
  344.   Token.Token_Id = END_OF_FILE_TOKEN;
  345.  
  346.   while (Token.Token_Id == END_OF_FILE_TOKEN)
  347.     {
  348.     Skip_Spaces (Data_File);
  349.  
  350.     c = getc(Data_File->File);
  351.     if (c == EOF)
  352.       {
  353.       if (Include_File_Index == 0)
  354.         {
  355.         Token.Token_Id = END_OF_FILE_TOKEN;
  356.         Token.End_Of_File = TRUE;
  357.         /*putchar ('\n');*/
  358.         fprintf (stderr,"\n");
  359.         return;
  360.         }
  361.       fclose(Data_File->File); /* added to fix open file buildup JLN 12/91 */
  362.       Data_File = &Include_Files[--Include_File_Index];
  363.       continue;
  364.       }
  365.  
  366.     String[0] = '\0';
  367.     String_Index  = 0;
  368.  
  369.     switch (c)
  370.     {
  371.     case '\n': 
  372.       Data_File->Line_Number++;
  373.       COOPERATE
  374.       break;
  375.  
  376.     case '{' : 
  377.       Write_Token (LEFT_CURLY_TOKEN, Data_File);
  378.       break;
  379.  
  380.     case '}' : 
  381.       Write_Token (RIGHT_CURLY_TOKEN, Data_File);
  382.       break;
  383.  
  384.     case '@' : 
  385.       Write_Token (AT_TOKEN, Data_File);
  386.       break;
  387.  
  388.     case '&' : 
  389.       Write_Token (AMPERSAND_TOKEN, Data_File);
  390.       break;
  391.  
  392.     case '`' : 
  393.       Write_Token (BACK_QUOTE_TOKEN, Data_File);
  394.       break;
  395.  
  396.     case '\\': 
  397.       Write_Token (BACK_SLASH_TOKEN, Data_File);
  398.       break;
  399.  
  400.     case '|' : 
  401.       Write_Token (BAR_TOKEN, Data_File);
  402.       break;
  403.  
  404.     case ':' : 
  405.       Write_Token (COLON_TOKEN, Data_File);
  406.       break;
  407.  
  408.     case ',' : 
  409.       Write_Token (COMMA_TOKEN, Data_File);
  410.       break;
  411.  
  412.     case '-' : 
  413.       Write_Token (DASH_TOKEN, Data_File);
  414.       break;
  415.  
  416.     case '$' : 
  417.       Write_Token (DOLLAR_TOKEN, Data_File);
  418.       break;
  419.  
  420.     case '=' : 
  421.       Write_Token (EQUALS_TOKEN, Data_File);
  422.       break;
  423.  
  424.     case '!' : 
  425.       Write_Token (EXCLAMATION_TOKEN, Data_File);
  426.       break;
  427.  
  428.     case '#' : /* Parser doesn't use it, so let's ignore it */
  429.       /* Write_Token (HASH_TOKEN, Data_File); */
  430.       break;
  431.  
  432.     case '^' : 
  433.       Write_Token (HAT_TOKEN, Data_File);
  434.       break;
  435.  
  436.     case '<' : 
  437.       Write_Token (LEFT_ANGLE_TOKEN, Data_File);
  438.       break;
  439.  
  440.     case '(' : 
  441.       Write_Token (LEFT_PAREN_TOKEN, Data_File);
  442.       break;
  443.  
  444.     case '[' : 
  445.       Write_Token (LEFT_SQUARE_TOKEN, Data_File);
  446.       break;
  447.  
  448.     case '%' : 
  449.       Write_Token (PERCENT_TOKEN, Data_File);
  450.       break;
  451.  
  452.     case '+' : 
  453.       Write_Token (PLUS_TOKEN, Data_File);
  454.       break;
  455.  
  456.     case '?' : 
  457.       Write_Token (QUESTION_TOKEN, Data_File);
  458.       break;
  459.  
  460.     case '>' : 
  461.       Write_Token (RIGHT_ANGLE_TOKEN, Data_File);
  462.       break;
  463.  
  464.     case ')' : 
  465.       Write_Token (RIGHT_PAREN_TOKEN, Data_File);
  466.       break;
  467.  
  468.     case ']' : 
  469.       Write_Token (RIGHT_SQUARE_TOKEN, Data_File);
  470.       break;
  471.  
  472.     case ';' : /* Parser doesn't use it, so let's ignore it */
  473.       /* Write_Token (SEMI_COLON_TOKEN, Data_File); */
  474.       break;
  475.  
  476.     case '\'': 
  477.       Write_Token (SINGLE_QUOTE_TOKEN, Data_File);
  478.       break;
  479.  
  480.       /* enable C++ style commenting */
  481.     case '/' :
  482.       c2 = getc(Data_File->File);
  483.       if(c2 != (int) '/' && c2 != (int) '*')
  484.         {
  485.         ungetc(c2,Data_File->File);
  486.         Write_Token (SLASH_TOKEN, Data_File);
  487.         break;
  488.         }          
  489.       if(c2 == (int)'*')
  490.         {
  491.         Parse_C_Comments(Data_File);
  492.         break;
  493.         }           
  494.       while(c2 != (int)'\n')
  495.         {
  496.         c2=getc(Data_File->File);
  497.         if(c2==EOF)
  498.           {
  499.           ungetc(c2,Data_File->File);
  500.           break;
  501.           }
  502.         }
  503.       Data_File->Line_Number++;
  504.       COOPERATE
  505.       break;
  506.  
  507.     case '*' : 
  508.       Write_Token (STAR_TOKEN, Data_File);
  509.       break;
  510.  
  511.     case '~' : 
  512.       Write_Token (TILDE_TOKEN, Data_File);
  513.       break;
  514.  
  515.     case '"' : 
  516.       Parse_String (Data_File);
  517.       break;
  518.  
  519.     case '0':   
  520.     case '1':   
  521.     case '2':   
  522.     case '3':   
  523.     case '4':   
  524.     case '5':
  525.     case '6':   
  526.     case '7':   
  527.     case '8':   
  528.     case '9':   
  529.     case '.':
  530.       ungetc (c, Data_File->File);
  531.       if (Read_Float (Data_File) != TRUE)
  532.         return;
  533.       break;
  534.  
  535.     case 'a': 
  536.     case 'b': 
  537.     case 'c': 
  538.     case 'd': 
  539.     case 'e': 
  540.     case 'f': 
  541.     case 'g':
  542.     case 'h': 
  543.     case 'i': 
  544.     case 'j': 
  545.     case 'k': 
  546.     case 'l': 
  547.     case 'm': 
  548.     case 'n':
  549.     case 'o': 
  550.     case 'p': 
  551.     case 'q': 
  552.     case 'r': 
  553.     case 's': 
  554.     case 't': 
  555.     case 'u':
  556.     case 'v': 
  557.     case 'w': 
  558.     case 'x': 
  559.     case 'y': 
  560.     case 'z':
  561.  
  562.     case 'A': 
  563.     case 'B': 
  564.     case 'C': 
  565.     case 'D': 
  566.     case 'E': 
  567.     case 'F': 
  568.     case 'G':
  569.     case 'H': 
  570.     case 'I': 
  571.     case 'J': 
  572.     case 'K': 
  573.     case 'L': 
  574.     case 'M': 
  575.     case 'N':
  576.     case 'O': 
  577.     case 'P': 
  578.     case 'Q': 
  579.     case 'R': 
  580.     case 'S': 
  581.     case 'T': 
  582.     case 'U':
  583.     case 'V': 
  584.     case 'W': 
  585.     case 'X': 
  586.     case 'Y': 
  587.     case 'Z': 
  588.     case '_':
  589.       ungetc (c, Data_File->File);
  590.       if (Read_Symbol (Data_File) != TRUE)
  591.         return;
  592.       break;
  593.     case '\t':
  594.     case '\r':
  595.     case '\032':   /* Control Z - EOF on many systems */
  596.     case '\0': 
  597.       break;
  598.  
  599.     default:
  600.       fprintf (stderr, "Error in %s line %d\n", Data_File->Filename, Data_File->Line_Number+1);
  601.       fprintf (stderr, "Illegal character in input file, value is %02x\n", c);
  602.       break;
  603.     }
  604.  
  605.     if (Token.Token_Id == INCLUDE_TOKEN)
  606.       {
  607.       if (Skip_Spaces (Data_File) != TRUE)
  608.         Token_Error (Data_File, "Expecting a string after INCLUDE\n");
  609.  
  610.       if ((c = getc(Data_File->File)) != '"')
  611.         Token_Error (Data_File, "Expecting a string after INCLUDE\n");
  612.  
  613.       Parse_String(Data_File);
  614.       Include_File_Index++;
  615.       if (Include_File_Index > MAX_INCLUDE_FILES)
  616.         Token_Error (Data_File, "Too many nested include files\n");
  617.  
  618.       Data_File = &Include_Files[Include_File_Index];
  619.       Data_File->Line_Number = 0;
  620.  
  621.       Data_File->Filename = malloc(strlen(Token.Token_String) + 1);
  622.       if (Data_File->Filename == NULL) 
  623.         MAError("opening include file");
  624.  
  625.       strcpy (Data_File->Filename, Token.Token_String);
  626.  
  627.       if ((Data_File->File = Locate_File (Token.Token_String, "r")) == NULL) 
  628.         {
  629.         fprintf (stderr, "Cannot open include file: %s\n", Token.Token_String);
  630.         exit(1);
  631.         }
  632.       Token.Token_Id = END_OF_FILE_TOKEN;
  633.       }
  634.  
  635.     }
  636.  
  637.   /*   fprintf(stderr," %s ",Token.Token_String); */
  638.   token_count++;
  639.   if (token_count > 1000)
  640.     {
  641.     token_count = 0;
  642.     COOPERATE
  643.     Check_User_Abort(0);
  644.     fprintf(stderr,".");
  645.     fflush(stderr);
  646.     line_count++;
  647.     if (line_count > 78)
  648.       {
  649.       line_count = 0;
  650.       fprintf (stderr,"\n");
  651.       }
  652.     }
  653.   return;
  654.   }
  655.  
  656.  
  657. /* Mark that the token has been put back into the input stream.  The next
  658. call to Get_Token will return the last-read token instead of reading a
  659. new one from the file. */
  660.  
  661. void Unget_Token ()
  662.   {
  663.   Token.Unget_Token = TRUE;
  664.   }
  665.  
  666. /* Skip over spaces in the input file */
  667.  
  668. int Skip_Spaces (Data_File)
  669. DATA_FILE *Data_File;
  670.   {
  671.   register int c;
  672.  
  673.   while (TRUE)
  674.     {
  675.     c = getc(Data_File->File);
  676.     if (c == EOF)
  677.       return (FALSE);
  678.  
  679.     if (!(isspace(c) || c == 0x0A))
  680.       break;
  681.  
  682.     if (c == '\n')
  683.       {
  684.        Data_File->Line_Number++;
  685.        COOPERATE
  686.       }
  687.     }
  688.  
  689.   ungetc (c, Data_File->File);
  690.   return (TRUE);
  691.   }
  692.  
  693. /* C style comments with asterik and slash - CdW 8/91 */
  694.  
  695. int Parse_C_Comments (Data_File)
  696. DATA_FILE *Data_File;
  697.   {
  698.   register int c,c2;
  699.   int End_Of_Comment;
  700.  
  701.   End_Of_Comment = FALSE;
  702.   while (!End_Of_Comment)
  703.     {
  704.     c = getc (Data_File->File);
  705.     if (c == EOF)
  706.       {
  707.       Token_Error (Data_File, "No */ closing comment found");
  708.       return (FALSE);
  709.       }
  710.  
  711.     if (c == (int) '\n')
  712.       {
  713.        Data_File->Line_Number++;
  714.        COOPERATE
  715.       }
  716.  
  717.     if (c == (int) '*')
  718.       {
  719.       c2= getc(Data_File->File);
  720.       if(c2 != (int) '/')
  721.         ungetc(c2,Data_File->File);
  722.       else
  723.         End_Of_Comment = TRUE;
  724.       }
  725.  
  726.     /* Check for and handle nested comments */
  727.     if (c == (int) '/')
  728.       {
  729.       c2= getc(Data_File->File);
  730.       if(c2 != (int) '*')
  731.         ungetc(c2,Data_File->File);
  732.       else 
  733.         Parse_C_Comments(Data_File);
  734.       }
  735.     }
  736.  
  737.   return (TRUE);
  738.   }
  739.  
  740. /* The following routines make it easier to handle strings.  They stuff
  741.    characters into a string buffer one at a time making all the proper
  742.    range checks.  Call Begin_String to start, Stuff_Character to put
  743.    characters in, and End_String to finish.  The String variable contains
  744.    the final string. */
  745.  
  746. void Begin_String()
  747.   {
  748.   String_Index = 0;
  749.   }
  750.  
  751. void Stuff_Character (c, Data_File)
  752. int c;
  753. DATA_FILE *Data_File;
  754.   {
  755.   if (String_Index < MAX_STRING_INDEX)
  756.     {
  757.     String [String_Index++] = (char) c;
  758.     if (String_Index >= MAX_STRING_INDEX)
  759.       {
  760.       Token_Error (Data_File, "String too long");
  761.       String [String_Index-1] = '\0';
  762.       }
  763.     }
  764.   }
  765.  
  766. void End_String (Data_File)
  767. DATA_FILE *Data_File;
  768.   {
  769.   Stuff_Character ((int) '\0', Data_File);
  770.   }
  771.  
  772. /* Read a float from the input file and tokenize it as one token. The phase
  773.    variable is 0 for the first character, 1 for all subsequent characters
  774.    up to the decimal point, 2 for all characters after the decimal
  775.    point, 3 for the E+/- and 4 for the exponent.  This helps to insure
  776.    that the number is formatted properly. E format added 9/91 CEY */
  777.  
  778. int Read_Float(Data_File)
  779. DATA_FILE *Data_File;
  780.   {
  781.   register int c, Finished, Phase;
  782.  
  783.   Finished = FALSE;
  784.   Phase = 0;
  785.  
  786.   Begin_String();
  787.   while (!Finished)
  788.     {
  789.     c = getc(Data_File->File);
  790.     if (c == EOF)
  791.       {
  792.       Token_Error (Data_File, "Unexpected end of file");
  793.       return (FALSE);
  794.       }
  795.  
  796.     switch (Phase)
  797.     {
  798.     case 0: 
  799.       if (isdigit(c))
  800.         Stuff_Character(c, Data_File);
  801.       else
  802.         if (c == '.') 
  803.         {
  804.         Stuff_Character('0', Data_File);
  805.         ungetc (c, Data_File->File);
  806.         }
  807.         else
  808.           Token_Error (Data_File, "Error in decimal number");
  809.       Phase = 1;
  810.       break;
  811.  
  812.     case 1: 
  813.       if (isdigit(c))
  814.         Stuff_Character(c, Data_File);
  815.       else if (c == (int) '.')
  816.         {
  817.         Stuff_Character(c, Data_File); Phase = 2;
  818.         }
  819.       else
  820.         if ((c == 'e') || (c == 'E'))
  821.           {
  822.           Stuff_Character(c, Data_File); Phase = 3;
  823.           }
  824.         else Finished = TRUE;
  825.       break;
  826.  
  827.       case 2: 
  828.         if (isdigit(c))
  829.           Stuff_Character(c, Data_File);
  830.         else if ((c == 'e') || (c == 'E'))
  831.           {
  832.           Stuff_Character(c, Data_File); Phase = 3;
  833.           }
  834.         else Finished = TRUE;
  835.       break;
  836.  
  837.       case 3: 
  838.         if (isdigit(c) || (c == '+') || (c == '-'))
  839.           {
  840.           Stuff_Character(c, Data_File); Phase = 4;
  841.           }
  842.         else Finished = TRUE;
  843.       break;
  844.  
  845.       case 4: 
  846.         if (isdigit(c))
  847.           Stuff_Character(c, Data_File);
  848.         else Finished = TRUE;
  849.       break;
  850.     }
  851.     }
  852.  
  853.     ungetc (c, Data_File->File);
  854.   End_String(Data_File);
  855.  
  856.   Write_Token (FLOAT_TOKEN, Data_File);
  857.   if (sscanf (String, DBL_FORMAT_STRING, &Token.Token_Float) == 0)
  858.     return (FALSE);
  859.  
  860.   return (TRUE);
  861.   }
  862.  
  863. /* Parse a string from the input file into a token. */
  864. void Parse_String (Data_File)
  865. DATA_FILE *Data_File;
  866.   {
  867.   register int c;
  868.  
  869.   Begin_String();
  870.   while (TRUE)
  871.     {
  872.     c = getc(Data_File->File);
  873.     if (c == EOF)
  874.       Token_Error (Data_File, "No end quote for string");
  875.  
  876.     if (c != (int) '"')
  877.       Stuff_Character (c, Data_File);
  878.     else
  879.       break;
  880.     }
  881.   End_String(Data_File);
  882.  
  883.   Write_Token (STRING_TOKEN, Data_File);
  884.   Token.Token_String = String;
  885.   }
  886.  
  887. /* Read in a symbol from the input file.  Check to see if it is a reserved
  888.    word.  If it is, write out the appropriate token.  Otherwise, write the
  889.    symbol out to the Symbol file and write out an IDENTIFIER token. An
  890.    Identifier token is a token whose token number is greater than the
  891.    highest reserved word. */
  892.  
  893. int Read_Symbol (Data_File)
  894. DATA_FILE *Data_File;
  895.   {
  896.   register int c, Symbol_Id;
  897.  
  898.   Begin_String();
  899.   while (TRUE)
  900.     {
  901.     c = getc(Data_File->File);
  902.     if (c == EOF)
  903.       {
  904.       Token_Error (Data_File, "Unexpected end of file");
  905.       return (FALSE);
  906.       }
  907.  
  908.     if (isalpha(c) || isdigit(c) || c == (int) '_')
  909.       Stuff_Character (c, Data_File);
  910.     else
  911.       {
  912.       ungetc (c, Data_File->File);
  913.       break;
  914.       }
  915.     }
  916.   End_String(Data_File);
  917.  
  918.   /* Ignore the symbol if it was meant for the tokenizer (-2) */
  919.   if ((Symbol_Id = Find_Reserved()) != -1 && Symbol_Id != -2)
  920.     Write_Token (Symbol_Id, Data_File);
  921.   else
  922.     {
  923.     /* Ignore the symbol if it was meant for the tokenizer (-2) */
  924.     if (Symbol_Id==-2)
  925.       return(TRUE);
  926.  
  927.     if ((Symbol_Id = Find_Symbol()) == -1)
  928.       if (++Number_Of_Symbols < Max_Symbols)
  929.         {
  930.         if ((Symbol_Table[Number_Of_Symbols] =
  931.           malloc (strlen(String)+1)) == NULL)
  932.           Token_Error (Data_File, "Out of Memory. Cannot allocate space for identifier");
  933.  
  934.         strcpy (Symbol_Table[Number_Of_Symbols], String);
  935.         Symbol_Id = Number_Of_Symbols;
  936.         }
  937.       else
  938.         {
  939.         fprintf (stderr, "\nToo many symbols. Use +ms### option to raise Max_Symbols\n");
  940.         exit(1);
  941.         }
  942.  
  943.     Write_Token (LAST_TOKEN + Symbol_Id, Data_File);
  944.     }
  945.  
  946.   return (TRUE);
  947.   }
  948.  
  949. /* Return the index the token in the reserved words table or -1 if it
  950.    isn't there. */
  951.  
  952. int Find_Reserved ()
  953.   {
  954.   register int i;
  955.  
  956.   if (pov_stricmp ("case_sensitive_yes", &(String[0])) == 0)
  957.     {
  958.     Case_Sensitive_Flag = 0;
  959.     return (-2);
  960.     }
  961.   else
  962.     if (pov_stricmp ("case_sensitive_no", &(String[0])) == 0)
  963.       {
  964.       Case_Sensitive_Flag = 1;
  965.       return (-2);
  966.       }
  967.   /* The optional case sensitive option only checks keywords
  968.              unsensitive.  Symbols can be upper/lower, but not be the
  969.              same as a keyword */
  970.     else
  971.       if (pov_stricmp ("case_sensitive_opt", &(String[0])) == 0)
  972.         {
  973.         Case_Sensitive_Flag = 2;
  974.         return (-2);
  975.         }
  976.  
  977.   for (i = 0 ; i < LAST_TOKEN ; i++)
  978.     if(Case_Sensitive_Flag==0)
  979.       {
  980.       if (strcmp (Reserved_Words[i].Token_Name, &(String[0])) == 0)
  981.         return (Reserved_Words[i].Token_Number);
  982.       }
  983.     else
  984.       if (pov_stricmp (Reserved_Words[i].Token_Name, &(String[0])) == 0)
  985.         return (Reserved_Words[i].Token_Number);
  986.  
  987.   return (-1);
  988.   }
  989.  
  990. /* Check to see if a symbol already exists with this name.  If so, return
  991.     its symbol ID. */
  992.  
  993. int Find_Symbol ()
  994.   {
  995.   register int i;
  996.  
  997.   for (i = 1 ; i <= Number_Of_Symbols ; i++)
  998.     if(Case_Sensitive_Flag == 0 || Case_Sensitive_Flag == 2)
  999.       if (strcmp (Symbol_Table[i], String) == 0)
  1000.         return (i);
  1001.       else if (Case_Sensitive_Flag == 1)
  1002.         if (pov_stricmp (Symbol_Table[i], String) == 0)
  1003.           return (i);
  1004.  
  1005.   return (-1);
  1006.   }
  1007.  
  1008. /* Report an error */
  1009. void Token_Error (Data_File, str)
  1010. DATA_FILE *Data_File;
  1011. char *str;
  1012.   {
  1013.   fprintf(stderr, "Error in %s line %d\n", Data_File->Filename, Data_File->Line_Number);
  1014.   fputs(str, stderr);
  1015.   fputs("\n\n", stderr);
  1016.   exit(1);
  1017.   }
  1018.  
  1019. /* Since the stricmp function isn't available on all systems, we've
  1020.    provided a simplified version of it here. */
  1021.  
  1022. static int pov_stricmp (s1, s2)
  1023. char *s1, *s2;
  1024.   {
  1025.   char c1, c2;
  1026.  
  1027.   while ((*s1 != '\0') && (*s2 != '\0')) 
  1028.     {
  1029.     c1 = *s1++;
  1030.     c2 = *s2++;
  1031.     if (islower(c1))
  1032.       c1 = (char) toupper(c1);
  1033.     if (islower(c2))
  1034.       c2 = (char) toupper(c2);
  1035.     if (c1 < c2)
  1036.       return (-1);
  1037.     if (c1 > c2)
  1038.       return (1);
  1039.     }
  1040.  
  1041.   if (*s1 == '\0')
  1042.     if (*s2 == '\0')
  1043.       return (0);
  1044.     else
  1045.       return (-1);
  1046.   else
  1047.     return (1);
  1048.   }
  1049.